home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / effects / effectClasses / ZoomInstance.as < prev   
Encoding:
Text File  |  2008-10-29  |  9.8 KB  |  316 lines
  1. package mx.effects.effectClasses
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.MouseEvent;
  5.    import mx.core.mx_internal;
  6.    import mx.effects.EffectManager;
  7.    import mx.events.FlexEvent;
  8.    
  9.    use namespace mx_internal;
  10.    
  11.    public class ZoomInstance extends TweenEffectInstance
  12.    {
  13.       mx_internal static const VERSION:String = "3.0.0.0";
  14.       
  15.       private var newY:Number;
  16.       
  17.       public var originY:Number;
  18.       
  19.       private var origX:Number;
  20.       
  21.       private var origY:Number;
  22.       
  23.       public var originX:Number;
  24.       
  25.       private var origPercentHeight:Number;
  26.       
  27.       public var zoomWidthFrom:Number;
  28.       
  29.       public var zoomWidthTo:Number;
  30.       
  31.       private var newX:Number;
  32.       
  33.       public var captureRollEvents:Boolean;
  34.       
  35.       private var origPercentWidth:Number;
  36.       
  37.       public var zoomHeightFrom:Number;
  38.       
  39.       private var origScaleX:Number;
  40.       
  41.       public var zoomHeightTo:Number;
  42.       
  43.       private var origScaleY:Number;
  44.       
  45.       private var scaledOriginX:Number;
  46.       
  47.       private var scaledOriginY:Number;
  48.       
  49.       private var show:Boolean = true;
  50.       
  51.       private var _mouseHasMoved:Boolean = false;
  52.       
  53.       public function ZoomInstance(param1:Object)
  54.       {
  55.          super(param1);
  56.       }
  57.       
  58.       override public function finishEffect() : void
  59.       {
  60.          if(captureRollEvents)
  61.          {
  62.             target.removeEventListener(MouseEvent.ROLL_OVER,mouseEventHandler,false);
  63.             target.removeEventListener(MouseEvent.ROLL_OUT,mouseEventHandler,false);
  64.             target.removeEventListener(MouseEvent.MOUSE_MOVE,mouseEventHandler,false);
  65.          }
  66.          super.finishEffect();
  67.       }
  68.       
  69.       private function getScaleFromWidth(param1:Number) : Number
  70.       {
  71.          return param1 / (target.width / Math.abs(target.scaleX));
  72.       }
  73.       
  74.       override public function initEffect(param1:Event) : void
  75.       {
  76.          super.initEffect(param1);
  77.          if(param1.type == FlexEvent.HIDE || param1.type == Event.REMOVED)
  78.          {
  79.             show = false;
  80.          }
  81.       }
  82.       
  83.       private function getScaleFromHeight(param1:Number) : Number
  84.       {
  85.          return param1 / (target.height / Math.abs(target.scaleY));
  86.       }
  87.       
  88.       private function applyPropertyChanges() : void
  89.       {
  90.          var _loc2_:Boolean = false;
  91.          var _loc3_:Boolean = false;
  92.          var _loc1_:PropertyChanges = propertyChanges;
  93.          if(_loc1_)
  94.          {
  95.             _loc2_ = false;
  96.             _loc3_ = false;
  97.             if(_loc1_.end["scaleX"] !== undefined)
  98.             {
  99.                zoomWidthFrom = isNaN(zoomWidthFrom) ? Number(target.scaleX) : zoomWidthFrom;
  100.                zoomWidthTo = isNaN(zoomWidthTo) ? Number(_loc1_.end["scaleX"]) : zoomWidthTo;
  101.                _loc3_ = true;
  102.             }
  103.             if(_loc1_.end["scaleY"] !== undefined)
  104.             {
  105.                zoomHeightFrom = isNaN(zoomHeightFrom) ? Number(target.scaleY) : zoomHeightFrom;
  106.                zoomHeightTo = isNaN(zoomHeightTo) ? Number(_loc1_.end["scaleY"]) : zoomHeightTo;
  107.                _loc3_ = true;
  108.             }
  109.             if(_loc3_)
  110.             {
  111.                return;
  112.             }
  113.             if(_loc1_.end["width"] !== undefined)
  114.             {
  115.                zoomWidthFrom = isNaN(zoomWidthFrom) ? getScaleFromWidth(target.width) : zoomWidthFrom;
  116.                zoomWidthTo = isNaN(zoomWidthTo) ? getScaleFromWidth(_loc1_.end["width"]) : zoomWidthTo;
  117.                _loc2_ = true;
  118.             }
  119.             if(_loc1_.end["height"] !== undefined)
  120.             {
  121.                zoomHeightFrom = isNaN(zoomHeightFrom) ? getScaleFromHeight(target.height) : zoomHeightFrom;
  122.                zoomHeightTo = isNaN(zoomHeightTo) ? getScaleFromHeight(_loc1_.end["height"]) : zoomHeightTo;
  123.                _loc2_ = true;
  124.             }
  125.             if(_loc2_)
  126.             {
  127.                return;
  128.             }
  129.             if(_loc1_.end["visible"] !== undefined)
  130.             {
  131.                show = _loc1_.end["visible"];
  132.             }
  133.          }
  134.       }
  135.       
  136.       private function mouseEventHandler(param1:MouseEvent) : void
  137.       {
  138.          if(param1.type == MouseEvent.MOUSE_MOVE)
  139.          {
  140.             _mouseHasMoved = true;
  141.          }
  142.          else if(param1.type == MouseEvent.ROLL_OUT || param1.type == MouseEvent.ROLL_OVER)
  143.          {
  144.             if(!_mouseHasMoved)
  145.             {
  146.                param1.stopImmediatePropagation();
  147.             }
  148.             _mouseHasMoved = false;
  149.          }
  150.       }
  151.       
  152.       override public function play() : void
  153.       {
  154.          super.play();
  155.          applyPropertyChanges();
  156.          if(isNaN(zoomWidthFrom) && isNaN(zoomWidthTo) && isNaN(zoomHeightFrom) && isNaN(zoomHeightTo))
  157.          {
  158.             if(show)
  159.             {
  160.                zoomWidthFrom = zoomHeightFrom = 0;
  161.                zoomWidthTo = target.scaleX;
  162.                zoomHeightTo = target.scaleY;
  163.             }
  164.             else
  165.             {
  166.                zoomWidthFrom = target.scaleX;
  167.                zoomHeightFrom = target.scaleY;
  168.                zoomWidthTo = zoomHeightTo = 0;
  169.             }
  170.          }
  171.          else
  172.          {
  173.             if(isNaN(zoomWidthFrom) && isNaN(zoomWidthTo))
  174.             {
  175.                zoomWidthFrom = zoomWidthTo = target.scaleX;
  176.             }
  177.             else if(isNaN(zoomHeightFrom) && isNaN(zoomHeightTo))
  178.             {
  179.                zoomHeightFrom = zoomHeightTo = target.scaleY;
  180.             }
  181.             if(isNaN(zoomWidthFrom))
  182.             {
  183.                zoomWidthFrom = target.scaleX;
  184.             }
  185.             else if(isNaN(zoomWidthTo))
  186.             {
  187.                zoomWidthTo = zoomWidthFrom == 1 ? 0 : 1;
  188.             }
  189.             if(isNaN(zoomHeightFrom))
  190.             {
  191.                zoomHeightFrom = target.scaleY;
  192.             }
  193.             else if(isNaN(zoomHeightTo))
  194.             {
  195.                zoomHeightTo = zoomHeightFrom == 1 ? 0 : 1;
  196.             }
  197.          }
  198.          if(zoomWidthFrom < 0.01)
  199.          {
  200.             zoomWidthFrom = 0.01;
  201.          }
  202.          if(zoomWidthTo < 0.01)
  203.          {
  204.             zoomWidthTo = 0.01;
  205.          }
  206.          if(zoomHeightFrom < 0.01)
  207.          {
  208.             zoomHeightFrom = 0.01;
  209.          }
  210.          if(zoomHeightTo < 0.01)
  211.          {
  212.             zoomHeightTo = 0.01;
  213.          }
  214.          origScaleX = target.scaleX;
  215.          origScaleY = target.scaleY;
  216.          newX = origX = target.x;
  217.          newY = origY = target.y;
  218.          if(isNaN(originX))
  219.          {
  220.             scaledOriginX = target.width / 2;
  221.          }
  222.          else
  223.          {
  224.             scaledOriginX = originX * origScaleX;
  225.          }
  226.          if(isNaN(originY))
  227.          {
  228.             scaledOriginY = target.height / 2;
  229.          }
  230.          else
  231.          {
  232.             scaledOriginY = originY * origScaleY;
  233.          }
  234.          scaledOriginX = Number(scaledOriginX.toFixed(1));
  235.          scaledOriginY = Number(scaledOriginY.toFixed(1));
  236.          origPercentWidth = target.percentWidth;
  237.          if(!isNaN(origPercentWidth))
  238.          {
  239.             target.width = target.width;
  240.          }
  241.          origPercentHeight = target.percentHeight;
  242.          if(!isNaN(origPercentHeight))
  243.          {
  244.             target.height = target.height;
  245.          }
  246.          tween = createTween(this,[zoomWidthFrom,zoomHeightFrom],[zoomWidthTo,zoomHeightTo],duration);
  247.          if(captureRollEvents)
  248.          {
  249.             target.addEventListener(MouseEvent.ROLL_OVER,mouseEventHandler,false);
  250.             target.addEventListener(MouseEvent.ROLL_OUT,mouseEventHandler,false);
  251.             target.addEventListener(MouseEvent.MOUSE_MOVE,mouseEventHandler,false);
  252.          }
  253.       }
  254.       
  255.       override public function onTweenEnd(param1:Object) : void
  256.       {
  257.          var _loc2_:Number = NaN;
  258.          var _loc3_:Number = NaN;
  259.          if(!isNaN(origPercentWidth))
  260.          {
  261.             _loc2_ = Number(target.width);
  262.             target.percentWidth = origPercentWidth;
  263.             if(Boolean(target.parent) && target.parent.autoLayout == false)
  264.             {
  265.                target.mx_internal::_width = _loc2_;
  266.             }
  267.          }
  268.          if(!isNaN(origPercentHeight))
  269.          {
  270.             _loc3_ = Number(target.height);
  271.             target.percentHeight = origPercentHeight;
  272.             if(Boolean(target.parent) && target.parent.autoLayout == false)
  273.             {
  274.                target.mx_internal::_height = _loc3_;
  275.             }
  276.          }
  277.          super.onTweenEnd(param1);
  278.          if(mx_internal::hideOnEffectEnd)
  279.          {
  280.             EffectManager.suspendEventHandling();
  281.             target.scaleX = origScaleX;
  282.             target.scaleY = origScaleY;
  283.             target.move(origX,origY);
  284.             EffectManager.resumeEventHandling();
  285.          }
  286.       }
  287.       
  288.       override public function onTweenUpdate(param1:Object) : void
  289.       {
  290.          EffectManager.suspendEventHandling();
  291.          if(Math.abs(newX - target.x) > 0.1)
  292.          {
  293.             origX += Number(target.x.toFixed(1)) - newX;
  294.          }
  295.          if(Math.abs(newY - target.y) > 0.1)
  296.          {
  297.             origY += Number(target.y.toFixed(1)) - newY;
  298.          }
  299.          target.scaleX = param1[0];
  300.          target.scaleY = param1[1];
  301.          var _loc2_:Number = param1[0] / origScaleX;
  302.          var _loc3_:Number = param1[1] / origScaleY;
  303.          var _loc4_:Number = scaledOriginX * _loc2_;
  304.          var _loc5_:Number = scaledOriginY * _loc3_;
  305.          newX = scaledOriginX - _loc4_ + origX;
  306.          newY = scaledOriginY - _loc5_ + origY;
  307.          newX = Number(newX.toFixed(1));
  308.          newY = Number(newY.toFixed(1));
  309.          target.move(newX,newY);
  310.          tween.mx_internal::needToLayout = true;
  311.          EffectManager.resumeEventHandling();
  312.       }
  313.    }
  314. }
  315.  
  316.